Django QuerySetlaridan ustunlik: Loyihalash funksiyasini maxsus menejerlar bilan kengaytirish

            # models.py

from django.db import models
from django.utils import timezone

class Product(models.Model):
    name = models.CharField(max_length=255)
    description = models.TextField()
    price = models.DecimalField(max_digits=10, decimal_places=2)
    is_available = models.BooleanField(default=True)
    discontinued_date = models.DateTimeField(null=True, blank=True)
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)

    def __str__(self):
        return self.name

            

              
                Copy
              
            
          

            # querysets.py (Yaxshiroq tashkilot uchun uni alohida faylda, yoki models.py ichida saqlashingiz mumkin)

from django.db import models
from django.utils import timezone

class ProductQuerySet(models.QuerySet):
    def available(self):
        """Faqat hozirda mavjud va to'xtatilmagan mahsulotlarni qaytaradi."""
        now = timezone.now()
        return self.filter(
            is_available=True,
            discontinued_date__isnull=True  # To'xtatish sanasi belgilanmagan
            # Alternativ ravishda, agar discontinued_date kelajak sanasi bo'lsa:
            # discontinued_date__gt=now 
        )

    def by_price_range(self, min_price, max_price):
        """Belgilangan narx oralig'idagi mahsulotlarni filtrlash."""
        return self.filter(price__gte=min_price, price__lte=max_price)

    def recently_added(self, days=7):
        """So'nggi 'days' kun ichida qo'shilgan mahsulotlarni qaytaradi."""
        cutoff_date = timezone.now() - timezone.timedelta(days=days)
        return self.filter(created_at__gte=cutoff_date)

            

              
                Copy
              
            
          

            # managers.py (Yana, tashkilot uchun, yoki models.py ichida)

from django.db import models
from .querysets import ProductQuerySet  # querysets.py mavjud deb taxmin qilinadi

class ProductManager(models.Manager):
    def get_queryset(self):
        return ProductQuerySet(self.model, using=self._db)

    # Siz menejerga bevosita QuerySet usullari bo'lmagan yoki QuerySet usullariga kirish nuqtalari bo'lib xizmat qiladigan usullarni ham qo'shishingiz mumkin.
    # Misol uchun, 'available' usuli uchun qisqa yo'l:
    def all_available(self):
        return self.get_queryset().available()

    def with_price_range(self, min_price, max_price):
        return self.get_queryset().by_price_range(min_price, max_price)

    def new_items(self, days=7):
        return self.get_queryset().recently_added(days)

            

              
                Copy
              
            
          

            # models.py

from django.db import models
from django.utils import timezone

# managers.py va querysets.py bir xil ilova katalogida joylashgan deb taxmin qilinadi
from .managers import ProductManager
# from .querysets import ProductQuerySet # Agar menejer uni boshqarsa, bu erda bevosita kerak emas

class Product(models.Model):
    name = models.CharField(max_length=255)
    description = models.TextField()
    price = models.DecimalField(max_digits=10, decimal_places=2)
    is_available = models.BooleanField(default=True)
    discontinued_date = models.DateTimeField(null=True, blank=True)
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)

    # Maxsus menejerdan foydalaning
    objects = ProductManager()

    def __str__(self):
        return self.name

            

              
                Copy
              
            
          

            # views.py, shell, yoki har qanday boshqa Python kodida:

from .models import Product

# Maxsus menejerning qisqa yo'llaridan foydalanish:

# Global miqyosda barcha mavjud mahsulotlarni oling
available_products_global = Product.objects.all_available()

# Belgilangan narx oralig'idagi mahsulotlarni oling (masalan, $50 va $200 AQSH dollari ekvivalenti orasida)
# Eslatma: Haqiqiy xalqaro valyuta boshqaruvi uchun sizga ko'proq murakkab mantiq kerak bo'ladi.
# Bu erda biz bir xil asosiy valyutani yoki ekvivalent narxni taxmin qilamiz.
featured_products = Product.objects.with_price_range(50.00, 200.00)

# So'nggi 3 kun ichida qo'shilgan mahsulotlarni oling
new_arrivals = Product.objects.new_items(days=3)

# Siz QuerySet usullarini ham zanjir bilan ulashingiz mumkin:

# Narx oralig'idagi mavjud mahsulotlarni oling, yaratilgan sanasi bo'yicha tartiblangan
sorted_products = Product.objects.all_available().by_price_range(10.00, 100.00).order_by('-created_at')

# Barcha mahsulotlarni oling, lekin keyin maxsus QuerySet usullaridan foydalaning:
# Agar menejer ushbu usullarga bevosita kirishni ta'minlasa, bu kamroq uchraydi.
# Siz odatda quyidagilar o'rniga Product.objects.available() dan foydalanasiz:
# Product.objects.get_queryset().available()

            

              
                Copy
              
            
          

            # querysets.py

from django.db import models
from django.utils import timezone

class PostQuerySet(models.QuerySet):
    def published(self):
        """Faqat nashr etilgan va hozirda mavjud bo'lgan postlarni qaytaradi."""
        return self.filter(is_published=True, published_date__lte=timezone.now())

    def for_locale(self, language_code='en', region_slug=None):
        """Ma'lum bir til va ixtiyoriy mintaqa uchun postlarni filtrlash."""
        qs = self.published().filter(language_code=language_code)
        if region_slug:
            qs = qs.filter(target_regions__slug=region_slug)
        return qs

    def most_recent_for_locale(self, language_code='en', region_slug=None):
        """Belgilangan til uchun eng so'nggi nashr etilgan postni olish."""
        return self.for_locale(language_code, region_slug).order_by('-published_date').first()

            

              
                Copy
              
            
          

            # views.py

from django.shortcuts import render
from .models import Post

def international_post_view(request):
    # Foydalanuvchining afzal ko'rgan tili/mintaqasini olish (soddalashtirilgan)
    user_lang = request.GET.get('lang', 'en')
    user_region = request.GET.get('region', None)

    # Ularning tiliga mos eng so'nggi postni olish
    latest_post = Post.objects.most_recent_for_locale(language_code=user_lang, region_slug=user_region)

    # Ularning tilida mavjud bo'lgan barcha postlar ro'yxatini olish
    all_posts_in_locale = Post.objects.for_locale(language_code=user_lang, region_slug=user_region)

    context = {
        'latest_post': latest_post,
        'all_posts': all_posts_in_locale,
    }
    return render(request, 'posts/international_list.html', context)

            

              
                Copy
              
            
          

            # querysets.py

from django.db import models
from django.utils import timezone

class TaskQuerySet(models.QuerySet):
    def blocked(self):
        """Hozirda to'siqli bo'lgan vazifalarni qaytaradi."""
        return self.filter(status='Blocked')

    def completed_by(self, user):
        """Belgilangan foydalanuvchi tomonidan bajarilgan vazifalarni qaytaradi."""
        return self.filter(status='Completed', completed_by=user)

    def due_soon(self, days=3):
        """Keyingi 'days' ichida bajarilishi kerak bo'lgan, tugallanmagan vazifalarni qaytaradi."""
        cutoff_date = timezone.now() + timezone.timedelta(days=days)
        return self.exclude(status='Completed').filter(due_date__lte=cutoff_date)

    def active_projects_tasks(self, project):
        """Aktiv bo'lgan loyihalar uchun vazifalarni qaytaradi."""
        return self.filter(project=project, project__is_active=True)

            

              
                Copy
              
            
          

            # views.py

from django.shortcuts import get_object_or_404
from .models import Task, User, Project

def project_dashboard(request, project_id):
    project = get_object_or_404(Project, pk=project_id)

    # Ushbu loyiha uchun vazifalarni oling
    project_tasks = Task.objects.filter(project=project)

    # Ushbu vazifalarda maxsus QuerySet usullaridan foydalaning
    due_tasks = project_tasks.due_soon()
    blocked_tasks = project_tasks.blocked()

    context = {
        'project': project,
        'due_tasks': due_tasks,
        'blocked_tasks': blocked_tasks,
    }
    return render(request, 'project/dashboard.html', context)

            

              
                Copy
              
            
          

            # querysets.py

from django.db import models
from django.utils import timezone
import pytz # pytz ni o'rnatish kerak: pip install pytz

class EventQuerySet(models.QuerySet):
    def happening_now(self, current_time=None):
        """Mahalliy vaqt zonasini hisobga olgan holda, hozirda davom etayotgan voqealarni filtrlash."""
        if current_time is None:
            current_time = timezone.now() # Bu UTC

        # UTC vaqt oralig'iga asoslangan holda potentsial faol voqealarni olish
        potential_events = self.filter(
            start_time__lte=current_time,
            end_time__gte=current_time
        )

        # Mahalliy vaqt zonasini tekshirish orqali yanada aniqlash
        # Bu murakkab, chunki Django ORM filtrlarda vaqt zonasi konversiyalarini osongina qo'llab-quvvatlamaydi.
        # Ko'pincha, bu konversiyani potentsial voqealarni olgandan keyin Python'da amalga oshirasiz.
        # Ko'rsatish uchun, biz tegishli UTC vaqtlarini olish va keyin Python'da filtrlashni soddalashtiramiz.
        return potential_events # Keyingi aniqlash odatda Python kodida amalga oshiriladi.

    def happening_today_in_timezone(self, target_timezone_name):
        """Belgilangan vaqt zonasida bugun sodir bo'layotgan voqealarni filtrlash."""
        try:
            target_timezone = pytz.timezone(target_timezone_name)
        except pytz.UnknownTimeZoneError:
            return self.none() # Yoki xatolikni ko'rsatish

        now_utc = timezone.now()
        today_start_utc = now_utc.replace(hour=0, minute=0, second=0, microsecond=0)
        today_end_utc = today_start_utc + timezone.timedelta(days=1)

        # Bugungi boshlanish va tugash vaqtlarini maqsadli vaqt zonasiga aylantirish
        today_start_local = target_timezone.localize(today_start_utc.replace(tzinfo=None))
        today_end_local = target_timezone.localize(today_end_utc.replace(tzinfo=None))

        # Voqea boshlanish/tugash vaqtlarini taqqoslash uchun maqsadli vaqt zonasiga aylantirishimiz kerak.
        # Bu aniqlik va to'g'rilik uchun Python'da eng yaxshi amalga oshiriladi.
        # Ma'lumotlar bazasi samaradorligi uchun siz UTC'da boshlanish/tugash vaqtlarini va vaqt zonasi nomini alohida saqlashingiz mumkin.
        # Keyin siz maqsadli kunning UTC ekvivalenti bilan o'ralashib qolgan voqealarni olasiz.

        # ORM-ga do'stona soddalashtirilgan yondashuv UTC kunining UTC vakili asosida filtrlashdir.
        # Maqsadli kunning UTC oralig'iga kiruvchi voqealarni toping.
        # Bu ko'p kunlik voqealarni o'z ichiga oladi, agar siz faqat o'sha hududdagi 'bugun'ni istasangiz.
        # Keyin aniq vaqt zonasi tekshiruvi Python'da amalga oshiriladi.
        
        # soddalashtirilgan yondashuv: maqsadli kunning UTC oynasiga kiruvchi boshlanish yoki tugash voqealarini oling.
        # Agar voqealar ko'p kunlik bo'lsa va siz faqat o'sha hududdagi 'bugun'ni istasangiz, bu aniqlanishni talab qiladi.
        # Aniqroq yondashuv har bir voqeani taqqoslash uchun maqsadli vaqt zonasiga aylantirishni o'z ichiga oladi.

        # Python-tomonlama filtrlash yondashuvini ko'rsatamiz:
        qs = self.filter(
            # UTC'da asosiy o'ralashish tekshiruvi
            start_time__lt=today_end_utc, 
            end_time__gt=today_start_utc
        )
        
        # Endi biz ularni maqsadli vaqt zonasi asosida Python'da filtrlashni amalga oshiramiz.
        relevant_events = []
        for event in qs:
            event_start_local = event.start_time.astimezone(target_timezone)
            event_end_local = event.end_time.astimezone(target_timezone)
            
            # Mahalliy vaqt zonasida bugungi kunning mahalliy sanasi bilan o'ralashishni tekshirish
            if event_start_local.date() == today_start_local.date() or 
               event_end_local.date() == today_start_local.date() or 
               (event_start_local.date() < today_start_local.date() and event_end_local.date() > today_start_local.date()):
                relevant_events.append(event)
        
        #natija qaytarish. Bu QuerySet emas, balki ro'yxat. Bu kompromis.
        return relevant_events # Bu ro'yxat qaytaradi, QuerySet emas. Bu kompromis.


# Modelni vaqt zonasi bilan ishlashni yanada aniqroq qilish uchun qayta ko'rib chiqaylik

class Event(models.Model):
    name = models.CharField(max_length=255)
    start_time = models.DateTimeField()
    end_time = models.DateTimeField()
    timezone_name = models.CharField(max_length=100, default='UTC') # Haqiqiy vaqt zonasi nomini saqlash

    objects = EventManager() # EventManager EventQuerySet dan foydalanadi deb taxmin qilinadi

    def get_local_start_time(self):
        return self.start_time.astimezone(pytz.timezone(self.timezone_name))

    def get_local_end_time(self):
        return self.end_time.astimezone(pytz.timezone(self.timezone_name))

    def is_happening_now(self):
        now_utc = timezone.now()
        return self.start_time <= now_utc and self.end_time >= now_utc

    def is_happening_today(self):
        now_utc = timezone.now()
        local_tz = pytz.timezone(self.timezone_name)
        
        event_start_local = self.start_time.astimezone(local_tz)
        event_end_local = self.end_time.astimezone(local_tz)
        
        today_local_date = now_utc.astimezone(local_tz).date()
        
        # Mahalliy vaqt zonasida bugungi kunning mahalliy sanasi bilan o'ralashishini tekshirish
        if event_start_local.date() == today_local_date or 
           event_end_local.date() == today_local_date or 
           (event_start_local.date() < today_local_date and event_end_local.date() > today_local_date):
            return True
        return False


# Vaqt zonasi uchun qayta ko'rib chiqilgan QuerySet va menejer

# querysets.py
from django.db import models
from django.utils import timezone
import pytz

class EventQuerySet(models.QuerySet):
    def for_timezone(self, tz_name):
        """Belgilangan vaqt zonasida faol yoki bugun faol bo'ladigan voqealarni qaytaradi."""
        try:
            tz = pytz.timezone(tz_name)
        except pytz.UnknownTimeZoneError:
            return self.none()

        now_utc = timezone.now()
        today_start_utc = now_utc.replace(hour=0, minute=0, second=0, microsecond=0)
        today_end_utc = today_start_utc + timezone.timedelta(days=1)

        # UTC vaqt oralig'i maqsadli kunning UTC ekvivalenti bilan o'ralashadigan voqealarni toping.
        # Bu fetched voqealar sonini kamaytirish uchun taxmindir.
        # Biz quyidagi voqealarni qidiramiz:
        # (event.start_time < today_end_utc) AND (event.end_time > today_start_utc)
        # Bu UTC kunining oralig'ida har qanday o'ralashishni ta'minlaydi.
        return self.filter(
            start_time__lt=today_end_utc,
            end_time__gt=today_start_utc
        ).order_by('start_time') # Qayta ishlashni osonlashtirish uchun tartiblash

# managers.py
from django.db import models
from .querysets import EventQuerySet

class EventManager(models.Manager):
    def get_queryset(self):
        return EventQuerySet(self.model, using=self._db)

    def happening_today_in_timezone(self, tz_name):
        """Belgilangan vaqt zonasida bugun sodir bo'layotgan voqealarni topadi."""
        # Potentsial tegishli voqealarni QuerySet usulidan foydalanib oling
        potential_events_qs = self.get_queryset().for_timezone(tz_name)

        # Endi aniq vaqt zonasi tekshiruvini Python'da amalga oshiramiz
        relevant_events = []
        try:
            target_tz = pytz.timezone(tz_name)
        except pytz.UnknownTimeZoneError:
            return [] # Agar vaqt zonasi yaroqsiz bo'lsa, bo'sh ro'yxatni qaytarish

        # Belgilangan vaqt zonasida bugungi kunning mahalliy sanasini oling
        today_local_date = timezone.now().astimezone(target_tz).date()

        for event in potential_events_qs:
            event_start_local = event.start_time.astimezone(target_tz)
            event_end_local = event.end_time.astimezone(target_tz)
            
            # Bugungi mahalliy sana bilan o'ralashishni tekshirish
            if event_start_local.date() == today_local_date or 
               event_end_local.date() == today_local_date or 
               (event_start_local.date() < today_local_date and event_end_local.date() > today_local_date):
                relevant_events.append(event)
        
        return relevant_events # Bu Event ob'ektlarining ro'yxati.

            

              
                Copy
              
            
          

            # models.py

from django.db import models

class Tenant(models.Model):
    name = models.CharField(max_length=100)
    # ... boshqa ijarador tafsilotlari

class TenantAwareQuerySet(models.QuerySet):
    def for_tenant(self, tenant):
        """Ma'lum bir ijaradorga tegishli ob'ektlarni filtrlash."""
        if tenant:
            return self.filter(tenant=tenant)
        return self.none() # Agar ijarador None bo'lsa, tegishlicha ishlov berish

class TenantAwareManager(models.Manager):
    def get_queryset(self):
        return TenantAwareQuerySet(self.model, using=self._db)

    def for_tenant(self, tenant):
        return self.get_queryset().for_tenant(tenant)

    def active(self):
        """Joriy ijarador uchun faol elementlarni qaytaradi (ijarador global miqyosda yoki o'tkazilgan deb taxmin qilinadi).
        Bu joriy ijaradorni olish mexanizmini taxmin qiladi, masalan, vositachilikdan yoki ipdan.
        """
        from .middleware import get_current_tenant 
        current_tenant = get_current_tenant()
        return self.for_tenant(current_tenant).filter(is_active=True)


class TenantModel(models.Model):
    tenant = models.ForeignKey(Tenant, on_delete=models.CASCADE)
    is_active = models.BooleanField(default=True)
    # ... boshqa maydonlar

    objects = TenantAwareManager()

    class Meta:
        abstract = True # Bu mixin-ga o'xshash naqsh

class Customer(TenantModel):
    name = models.CharField(max_length=255)
    # ...boshqa mijoz maydonlari

# Foydalanish:
# from .models import Customer
# current_tenant = Tenant.objects.get(name='Globex Corp.')
# customers_for_globex = Customer.objects.for_tenant(current_tenant)
# active_customers_globex = Customer.objects.active() # get_current_tenant() to'g'ri o'rnatilgan deb taxmin qilinadi

            

              
                Copy